
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.brain.sele.view.mbean;

import com.brain.core.common.UtilCore;
import com.brain.core.configuracion.WebServletContextListener;
import com.brain.core.dto.ParametroDto;
import com.brain.core.view.mbean.*;
import com.brain.core.manager.RecursosManager;
import com.brain.sele.dto.CalificacionDto;
import com.brain.sele.dto.ConvocatoriaDto;
import com.brain.sele.dto.ConvocatoriaEvaluacionDto;
import com.brain.sele.dto.PostulanteDto;
import com.brain.sele.dto.RequerimientoDto;
import com.brain.sele.dto.ResponsableDto;
import com.brain.sele.manager.CalificacionManager;
import com.brain.sele.manager.ConvocatoriaEvaluacionManager;
import com.brain.sele.manager.ConvocatoriaManager;
import com.brain.sele.manager.PostulanteManager;
import com.brain.sele.manager.RequerimientoManager;
import com.brain.sele.manager.ResponsableManager;
import com.brain.sele.manager.SeguimientoConvocatoriaManager;
import com.brain.sele.view.util.ConstantesSele;
import com.brain.sgc.dto.ProcesoSGCDto;
import com.brain.sgc.view.util.ConstantesSgc;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

import javax.annotation.Resource;
import javax.faces.event.ActionEvent;
import org.apache.log4j.Logger;
import org.primefaces.context.RequestContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;

/**
 *
 * @author Hvives
 */
@Controller("seguimientoConvocatoriaMBean")
@Scope("session")
public class SeguimientoConvocatoriaMBean extends GenericMBean implements Serializable {

    private static Logger logger = Logger.getLogger(SeguimientoConvocatoriaMBean.class);
    @Resource
    private SeguimientoConvocatoriaManager manager;
    @Resource
    private RecursosManager recursosManager;
    @Resource
    private ResponsableManager responsableManager;
    @Resource
    private CalificacionManager calificacionManager;
    @Resource
    private RequerimientoManager requerimientoManager;
    @Resource
    private PostulanteManager postulanteManager;
    @Resource
    private ConvocatoriaManager convocatoriaManager;
    @Resource
    private ConvocatoriaEvaluacionManager convEvalManager;
    private List<ConvocatoriaDto> lista;
    private ConvocatoriaDto dto;
    private ConvocatoriaDto dtoFiltroS;
    private String keyTitulo = "seguimimento.convocatoria.panel";
    @Autowired
    private ApplicationMBean applicationMBean;
    @Autowired
    private SessionMBean sessionMBean;
    private List<ProcesoSGCDto> listaProcesosFiltro;
    private RequerimientoDto requerimientoDto;
    private List<CalificacionDto> listaCalificacionesDto;
    private List<RequerimientoDto> listaConvReqAprobados;
    private Boolean accesoBtnPasarEtapa;
    private Boolean accesoBtnFinalizarEval;
    private Boolean accesoBtnGuardar;
    private String urlInvocador;
    private Boolean accesoBtnTerminarConv;

    public SeguimientoConvocatoriaMBean() {
        this.dtoFiltroS = new ConvocatoriaDto();
    }

    public String iniciar() {
        this.dto = null;
        this.lista = null;
        this.dtoFiltroS = new ConvocatoriaDto();
        this.dtoFiltroS.setProcesoDto(new ProcesoSGCDto());
        return ConstantesSele.UrlNavegacion.URL_LISTA_SEGUIMIMENTO_CONVOCATORIA;
    }

    public void buscar(ActionEvent ae) {

        try {
            if (this.dtoFiltroS != null) {
                this.lista = this.manager.obtenerConvPublicadas(this.dtoFiltroS);
            }
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }

    }

    public String verRequerimientosAux() {
        sessionMBean.setTitulo(recursosManager.construirTitulo(keyTitulo, sessionMBean.getAccion()));
        this.agregarColumnasAdicionales();
        return ConstantesSele.UrlNavegacion.URL_LISTA_SEGUIMIMENTO_REQ_POR_CONV;
    }

    public String verRequerimientos() {
        sessionMBean.setTitulo(recursosManager.construirTitulo(keyTitulo, sessionMBean.getAccion()));
        this.urlInvocador = null;
        this.agregarColumnasAdicionales();
        return ConstantesSele.UrlNavegacion.URL_LISTA_SEGUIMIMENTO_REQ_POR_CONV;
    }

    public String cargarPopupCalificar() {
        this.accesoBtnPasarEtapa = true;
        this.accesoBtnGuardar = true;
        try {
            if (this.requerimientoDto.getEtapaActualDto().getOrden() > 1) {
                this.listaCalificacionesDto = this.calificacionManager.obtenerPostulantesAptosPorEtapa(this.requerimientoDto);
            } else {
                this.listaCalificacionesDto = this.calificacionManager.obtenerCalificacionesPorEtapa(this.requerimientoDto);
            }
            this.gestionAccesoBotonesPopup();
            if (this.listaCalificacionesDto.isEmpty()) {
                this.accesoBtnGuardar = false;
                this.accesoBtnPasarEtapa = false;
            }

            showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("popup.calificar.msg.info"));
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }

        if (!this.verificarCantPostParaSiguienteEtapa()) {
            showWarning(UtilCore.Internacionalizacion.getMensajeInternacional("convocatoria.mensaje.req.sin.postulantes"));
        }

        return "";
    }

    protected Boolean verificarCantPostParaSiguienteEtapa() {
        int cont = 0;
        for (CalificacionDto c : this.listaCalificacionesDto) {
            if (c.getEstadoDto().getId().equals(ConstantesSele.Parametro.CALIF_ESTADO_DESAPROBADO) || c.getEstadoDto().getId().equals(ConstantesSele.Parametro.CALIF_ESTADO_DESISTIDO)) {
                cont++;
            }
        }
        if (cont == this.listaCalificacionesDto.size()) {
            return false;
        }
        return true;
    }

    protected void gestionAccesoBotonesPopup() {
        this.accesoBtnPasarEtapa = true;
        this.accesoBtnFinalizarEval = false;
        //Veririficamos si existe una etapa posterior para ocultar el boton PASAR ETAPA
        try {
            List<ConvocatoriaEvaluacionDto> listaConvEval = this.convEvalManager.obtenerEvaluacionPorOrdenyConv((Long) (this.requerimientoDto.getEtapaActualDto().getOrden() + 1), this.requerimientoDto.getConvocatoriaDto().getId());
            if (listaConvEval.isEmpty()) {
                this.accesoBtnPasarEtapa = false;
                this.accesoBtnFinalizarEval = true;
            }
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }

    public void agregarColumnasAdicionales() {
        this.accesoBtnTerminarConv = false;
        try {
            int contReq = 0;
            this.listaConvReqAprobados = this.requerimientoManager.obtenerReqAprobadosPorConvocatoria(this.dto.getId());
            for (RequerimientoDto req : this.listaConvReqAprobados) {
                if (req.getEstadoDto().getId().equals(ConstantesSele.Parametro.REQ_ESTADO_EVALUADO)) {
                    contReq++;
                }
                int evaluados = 0;
                int aprobados = 0;
                int desaprobados = 0;
                int aptos = 0;
                if (req.getEtapaActualDto().getOrden() > 1) {
                    this.listaCalificacionesDto = this.calificacionManager.obtenerPostulantesAptosPorEtapa(req);
                } else {
                    this.listaCalificacionesDto = this.calificacionManager.obtenerCalificacionesPorEtapa(req);
                }
                for (CalificacionDto calif : this.listaCalificacionesDto) {
                    if (!calif.getEstadoDto().getId().equals(ConstantesSele.Parametro.CALIF_ESTADO_PENDIENTE)) {
                        evaluados++;
                    }
                    if (calif.getEstadoDto().getId().equals(ConstantesSele.Parametro.CALIF_ESTADO_APROBADO)) {
                        aprobados++;
                    }
                    if (calif.getEstadoDto().getId().equals(ConstantesSele.Parametro.CALIF_ESTADO_DESAPROBADO)) {
                        desaprobados++;
                    }
                }
                //Recuperamos al responsable de la ETAPA ACTUAL 
                List<ResponsableDto> lrespDto = this.responsableManager.obtenerResponsablePorReqYEtapaActual(req.getId(), req.getEtapaActualDto().getId());
                if (!lrespDto.isEmpty()) {
                    ResponsableDto respDto = lrespDto.get(0);
                    req.setResponsableDto(respDto);
                }
                req.setTotalPostulantes(this.postulanteManager.obtenerCantPostulantesPorRequerimiento(req.getId()));
                req.setPostulantes(this.listaCalificacionesDto.size());
                req.setEvaluados(evaluados);
                req.setAprobados(aprobados);
                req.setDesaprobados(desaprobados);
            }
            if (contReq == this.listaConvReqAprobados.size()) {
                this.accesoBtnTerminarConv = true;
            }

        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }

    }

    public String calificarPostPorEtapa() {
        List<CalificacionDto> lstCalificacion = new ArrayList<CalificacionDto>();
        PostulanteDto postulanteDtoAux = null;
        try {
            if (this.validarNotaMaxima()) {
                for (CalificacionDto calif : this.listaCalificacionesDto) {
                    postulanteDtoAux = new PostulanteDto();
                    postulanteDtoAux = this.postulanteManager.obtenerPorId(calif.getPostulanteDto().getId());
                    if (calif.getDesistir()) {
                        calif.setEstadoDto(new ParametroDto(ConstantesSele.Parametro.CALIF_ESTADO_DESISTIDO));
                        calif.setNota(null);
                        //Actualizamos el estado del postulante y obtenemos el acumulado de sus notas
                         List<CalificacionDto> califPorPostulante = this.calificacionManager.obtenerCalificacionesPorPostulante(calif.getPostulanteDto().getId());
                                postulanteDtoAux.setAcumulado(this.obtenerNotaAcumulada(califPorPostulante));
                        postulanteDtoAux.setEstadoDto(new ParametroDto(ConstantesSele.Parametro.POST_ESTADO_DESISTIDO));
                        postulanteDtoAux.setComentarioDesistir(calif.getComentarioDesistir());
                    } else {
                        if (calif.getNota() != null && calif.getNota().compareTo(BigDecimal.valueOf(0)) >= 0) {
                            if (calif.getConvocatoriaEvalDto().getNotaMinimaAprob().compareTo(calif.getNota()) > 0) {
                                calif.setEstadoDto(new ParametroDto(ConstantesSele.Parametro.CALIF_ESTADO_DESAPROBADO));
                                //Actualizamos el estado del postulante y obtenemos el acumulado de sus notas
                                List<CalificacionDto> califPorPostulante = this.calificacionManager.obtenerCalificacionesPorPostulante(calif.getPostulanteDto().getId());
                                postulanteDtoAux.setAcumulado(this.obtenerNotaAcumulada(califPorPostulante));
                                postulanteDtoAux.setEstadoDto(new ParametroDto(ConstantesSele.Parametro.POST_ESTADO_DESAPROBADO));
                                postulanteDtoAux.setComentarioDesistir(calif.getComentarioDesistir());
                            } else {
                                calif.setEstadoDto(new ParametroDto(ConstantesSele.Parametro.CALIF_ESTADO_APROBADO));
                                calif.setDesistir(Boolean.FALSE);
                                //Actualizamos el estado del postulante
                                postulanteDtoAux.setEstadoDto(new ParametroDto(ConstantesSele.Parametro.POST_ESTADO_EVALUACION));
                                postulanteDtoAux.setComentarioDesistir(null);
                            }
                        } else {
                            calif.setEstadoDto(new ParametroDto(ConstantesSele.Parametro.CALIF_ESTADO_PENDIENTE));
                            calif.setDesistir(Boolean.FALSE);
                            postulanteDtoAux.setEstadoDto(new ParametroDto(ConstantesSele.Parametro.POST_ESTADO_EVALUACION));
                            postulanteDtoAux.setComentarioDesistir(null);
                        }
                    }
                    UtilCore.General.toUpperCaseDto(calif);
                    UtilCore.General.toUpperCaseDto(postulanteDtoAux);
                    lstCalificacion.add(calif);
                    this.postulanteManager.editar(postulanteDtoAux);
                }
                this.calificacionManager.nuevoMuchos(lstCalificacion);
                this.agregarColumnasAdicionales();
                this.cargarPopupCalificar();
                //Actualizamos el campo del requerimiento que indica que la evaluacion ha iniciado
                this.requerimientoDto.setComenzoEvaluacion(Boolean.TRUE);
                this.requerimientoManager.editar(this.requerimientoDto);
                showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("popup.calificar.mensaje.notas_ingresadas_ok"));
            } else {
                showWarning(UtilCore.Internacionalizacion.getMensajeInternacional("popup.calificar.mensaje.notas_maxima"));
            }
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
        return "";
    }

    public Boolean validarNotaMaxima() {
        for (CalificacionDto calif : this.listaCalificacionesDto) {
            if (calif.getNota() != null) {
                if (calif.getNota().compareTo(calif.getConvocatoriaEvalDto().getNotaMaxima()) > 0) {
                    return false;
                }
            }
        }
        return true;
    }

    public void pasarEtapaSiguiente() {
        RequestContext context = RequestContext.getCurrentInstance();
        Boolean resultado = true;
        try {
            if (this.verificarNotasLlenasPorEtapaActual()) {//Verificamos si todas las notas han sido ingresadas
                //Verificamos si existe una etapa posterior
                if (!this.verificarCantPostParaSiguienteEtapa()) {
                    //Finalizamos el requerimiento por falta de postulantes
                    this.requerimientoDto.setEstadoDto(new ParametroDto(ConstantesSele.Parametro.REQ_ESTADO_EVALUADO));
                    this.requerimientoDto.setComentario(UtilCore.Internacionalizacion.getMensajeInternacional("requerimiento.comentario.sin.postulantes"));
                    this.requerimientoManager.editar(this.requerimientoDto);
                } else {
                    List<ConvocatoriaEvaluacionDto> listaConvEval = this.convEvalManager.obtenerEvaluacionPorOrdenyConv((Long) (this.requerimientoDto.getEtapaActualDto().getOrden() + 1), this.requerimientoDto.getConvocatoriaDto().getId());
                    if (!listaConvEval.isEmpty()) {
                        ConvocatoriaEvaluacionDto convEvalDto = listaConvEval.get(0);
                        this.requerimientoDto.setEtapaActualDto(convEvalDto);
                        this.requerimientoManager.editar(this.requerimientoDto);
                    }
                }
                this.agregarColumnasAdicionales();
            } else {
                resultado = false;
                showError(UtilCore.Internacionalizacion.getMensajeInternacional("popup.calificar.mensaje.notas_no_llenas"));
            }
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
        context.addCallbackParam("CallbackParam", resultado);
    }

    public void finalizarRequerimiento() {
        RequestContext context = RequestContext.getCurrentInstance();
        boolean resultado = true;
        try {
            List<CalificacionDto> calificaciones = new ArrayList<CalificacionDto>();
            if (this.requerimientoDto.getEtapaActualDto().getOrden() > 1) {
                calificaciones = this.calificacionManager.obtenerPostulantesPorEtapaVarias(this.requerimientoDto);
            } else {
                calificaciones = this.calificacionManager.obtenerPostulantesPorEtapaUna(this.requerimientoDto);
            }
            List<CalificacionDto> califPorPostulante = null;
            if (this.verificarNotasLlenasPorEtapaActual()) {
                //Recuperamos los postulantes de la ultima etapa
                for (CalificacionDto calif : calificaciones) {
                    //Obtenemos las etapas por requerimiento del postulante
                    califPorPostulante = this.calificacionManager.obtenerCalificacionesPorPostulante(calif.getPostulanteDto().getId());
                    //Actualizamos el postulante
                    PostulanteDto dtoPost = this.postulanteManager.obtenerPorId(calif.getPostulanteDto().getId());
                    BigDecimal notaFinal = this.obtenerNotaFinal(califPorPostulante);
                    dtoPost.setNotaFinal(UtilCore.Numero.round(notaFinal, 2));
                    dtoPost.setAcumulado(this.obtenerNotaAcumulada(califPorPostulante));
                    if (calif.getEstadoDto().getId().equals(ConstantesSele.Parametro.CALIF_ESTADO_APROBADO)) {
                        dtoPost.setEstadoDto(new ParametroDto(ConstantesSele.Parametro.POST_ESTADO_APROBADO));
                    } else if (calif.getEstadoDto().getId().equals(ConstantesSele.Parametro.CALIF_ESTADO_DESAPROBADO)) {
                        dtoPost.setEstadoDto(new ParametroDto(ConstantesSele.Parametro.POST_ESTADO_DESAPROBADO));
                    }
                    this.postulanteManager.editar(dtoPost);
                }

                //Una vez calculadas las notas finales de los postulantes procedemos a identificar a los postulantes SELECCIONADOS
                //en base al numero de vacantes estipulado en el requerimiento
                List<PostulanteDto> lPost = this.postulanteManager.obtenerPostulantesAprobadosPorReq(this.requerimientoDto.getId());
                //Obtenemos el numero de vacantes del requerimiento
                int numVacantes = this.requerimientoDto.getNumeroVacantes().intValue();
                int cont = 0;
                for (PostulanteDto p : lPost) {
                    cont++;
                    if (cont <= numVacantes) {
                        p.setEstadoDto(new ParametroDto(ConstantesSele.Parametro.POST_ESTADO_SELECCIONADO));
                        this.postulanteManager.editar(p);
                    }
                }
                //Actualizamos el estado del requerimiento a EVALUADO
                this.requerimientoDto.setEstadoDto(new ParametroDto(ConstantesSele.Parametro.REQ_ESTADO_EVALUADO));
                this.requerimientoManager.editar(this.requerimientoDto);
                //Obtenemos nuevamente la lista de req no evaluados por convocatoria
                this.agregarColumnasAdicionales();
            } else {
                resultado = false;
                showError(UtilCore.Internacionalizacion.getMensajeInternacional("popup.calificar.mensaje.finalizar_eval.notas_no_llenas"));
            }
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
        context.addCallbackParam("CallbackParam", resultado);
    }

    protected BigDecimal obtenerNotaFinal(List<CalificacionDto> listaCalif) {
        BigDecimal notaFinal = BigDecimal.ZERO;
        //Obtener pesos (%) por evaluacion
        for (CalificacionDto c : listaCalif) {
            if (c.getNota() != null) {
                notaFinal = notaFinal.add(c.getNota().multiply(UtilCore.Numero.dividir(c.getConvocatoriaEvalDto().getPorcentaje(), c.getConvocatoriaEvalDto().getConvocatoriaDto().getPeso(), 2)));
            }

        }
        return notaFinal;
    }
    
    protected BigDecimal obtenerNotaAcumulada (List<CalificacionDto> listaCalif) {
        BigDecimal notaAcumulada = BigDecimal.ZERO;
        //Obtener pesos (%) por evaluacion
        for (CalificacionDto c : listaCalif) {
            if (c.getNota() != null) {
                notaAcumulada = notaAcumulada.add(c.getNota());
            }

        }
        return notaAcumulada;
    }

    public Boolean verificarNotasLlenasPorEtapaActual() {
        Boolean indicador = true;
        this.cargarPopupCalificar();
        for (CalificacionDto calif : this.listaCalificacionesDto) {
            if (calif.getNota() == null) {
                if (!calif.getEstadoDto().getId().equals(ConstantesSele.Parametro.CALIF_ESTADO_DESISTIDO)) {
                    indicador = false;
                }
            }
        }
        return indicador;
    }

    public String iraTerminarConvocatoria() {
        ConvocatoriaMBean convocatoriaMBean = (ConvocatoriaMBean) WebServletContextListener.getApplicationContext().getBean("convocatoriaMBean");
        try {
            convocatoriaMBean.iniciarDatosFiltro();
            this.dto = this.convocatoriaManager.obtenerConvocatoriaPorId(this.dto.getId());
            convocatoriaMBean.setDto(this.dto);
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
        return convocatoriaMBean.editar();
    }

    public String retroceder() {
        buscar(null);
        sessionMBean.setAccion(ConstantesSgc.Formulario.LISTA);
        sessionMBean().setTitulo(recursosManager.construirTitulo(keyTitulo, sessionMBean().getAccion()));
        if (this.urlInvocador != null && this.urlInvocador.length() != 0) {
            return this.urlInvocador;
        } else {
            return ConstantesSele.UrlNavegacion.URL_LISTA_SEGUIMIMENTO_CONVOCATORIA;
        }
    }

    public ConvocatoriaDto getDto() {
        return dto;
    }

    public void setDto(ConvocatoriaDto dto) {
        this.dto = dto;
    }

    public String getKeyTitulo() {
        return keyTitulo;
    }

    public void setKeyTitulo(String keyTitulo) {
        this.keyTitulo = keyTitulo;
    }

    public List<ConvocatoriaDto> getLista() {
        return lista;
    }

    public void setLista(List<ConvocatoriaDto> lista) {
        this.setLista(lista);
    }

    public ConvocatoriaDto getDtoFiltroS() {
        return dtoFiltroS;
    }

    public void setDtoFiltroSS(ConvocatoriaDto dtoFiltroS) {
        this.dtoFiltroS = dtoFiltroS;
    }

    public List<ProcesoSGCDto> getListaProcesosFiltro() {
        return this.recursosManager.obtenerProcesosActivosCombo();
    }

    public void setListaProcesosFiltro(List<ProcesoSGCDto> listaProcesosFiltro) {
        this.listaProcesosFiltro = listaProcesosFiltro;
    }

    public RecursosManager getRecursosManager() {
        return recursosManager;
    }

    public void setRecursosManager(RecursosManager recursosManager) {
        this.recursosManager = recursosManager;
    }

    public ApplicationMBean getApplicationMBean() {
        return applicationMBean;
    }

    public void setApplicationMBean(ApplicationMBean applicationMBean) {
        this.applicationMBean = applicationMBean;
    }

    public SessionMBean getSessionMBean() {
        return sessionMBean;
    }

    public void setSessionMBean(SessionMBean sessionMBean) {
        this.sessionMBean = sessionMBean;
    }

    public static Logger getLogger() {
        return logger;
    }

    public static void setLogger(Logger logger) {
        SeguimientoConvocatoriaMBean.logger = logger;
    }

    public RequerimientoDto getRequerimientoDto() {
        return requerimientoDto;
    }

    public void setRequerimientoDto(RequerimientoDto requerimientoDto) {
        this.requerimientoDto = requerimientoDto;
    }

    public List<CalificacionDto> getListaCalificacionesDto() {
        return listaCalificacionesDto;
    }

    public void setListaCalificacionesDto(List<CalificacionDto> listaCalificacionesDto) {
        this.listaCalificacionesDto = listaCalificacionesDto;
    }

    public Boolean getAccesoBtnPasarEtapa() {
        return accesoBtnPasarEtapa;
    }

    public void setAccesoBtnPasarEtapa(Boolean accesoBtnPasarEtapa) {
        this.accesoBtnPasarEtapa = accesoBtnPasarEtapa;
    }

    public Boolean getAccesoBtnFinalizarEval() {
        return accesoBtnFinalizarEval;
    }

    public void setAccesoBtnFinalizarEval(Boolean accesoBtnFinalizarEval) {
        this.accesoBtnFinalizarEval = accesoBtnFinalizarEval;
    }

    public List<RequerimientoDto> getListaConvReqAprobados() {
        return listaConvReqAprobados;
    }

    public void setListaConvReqAprobados(List<RequerimientoDto> listaConvReqAprobados) {
        this.listaConvReqAprobados = listaConvReqAprobados;
    }

    public Boolean getAccesoBtnGuardar() {
        return accesoBtnGuardar;
    }

    public void setAccesoBtnGuardar(Boolean accesoBtnGuardar) {
        this.accesoBtnGuardar = accesoBtnGuardar;
    }

    public String getUrlInvocador() {
        return urlInvocador;
    }

    public void setUrlInvocador(String urlInvocador) {
        this.urlInvocador = urlInvocador;
    }

    public Boolean getAccesoBtnTerminarConv() {
        return accesoBtnTerminarConv;
    }

    public void setAccesoBtnTerminarConv(Boolean accesoBtnTerminarConv) {
        this.accesoBtnTerminarConv = accesoBtnTerminarConv;
    }
}
